time_stamp.h

Go to the documentation of this file.

// WOLF - Copyright (C) 2020-2026
// Institut de Robòtica i Informàtica Industrial, CSIC-UPC.
// Authors: Joan Solà Ortega (jsola@iri.upc.edu) and
// Joan Vallvé Navarro (jvallve@iri.upc.edu)
// All rights reserved.
//
// This file is part of WOLF: http://www.iri.upc.edu/wolf
// WOLF is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 3
// as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
 
// wolf includes
#include "core/common/wolf.h"
 
// C, std
#include <sys/time.h>
#include <iostream>
#include <iomanip>
 
static const unsigned int NANOSECS = 1000000000;
 
namespace wolf
{
class TimeStamp
{
  protected:
    unsigned long int time_stamp_nano_;  
    bool              is_valid_;         // time stamp has a valid value
 
  public:
    TimeStamp();
 
    TimeStamp(const TimeStamp& _ts);
 
    TimeStamp(const double& _ts);
 
    TimeStamp(const unsigned long int& _sec, const unsigned long int& _nsec);
 
    ~TimeStamp();
 
    static TimeStamp Invalid();
    bool             ok() const;
    void             setOk();
    void             setNOk();
 
    static TimeStamp Now();
 
    void setToNow();
 
    void set(const timeval& ts);
 
    void set(const unsigned long int& sec, const unsigned long int& nanosec);
 
    void set(const double& ts);
 
    double get() const;
 
    unsigned long int getSeconds() const;
 
    unsigned long int getNanoSeconds() const;
 
    void operator=(const double& ts);
 
    void operator=(const TimeStamp& ts);
 
    bool operator!=(const TimeStamp& ts) const;
    bool operator==(const TimeStamp& ts) const;
    bool operator<(const TimeStamp& ts) const;
    bool operator>(const TimeStamp& ts) const;
 
    bool operator<=(const TimeStamp& ts) const;
    bool operator>=(const TimeStamp& ts) const;
 
    void operator+=(const double& dt);
 
    TimeStamp operator+(const double& dt) const;
 
    void operator-=(const double& dt);
 
    TimeStamp operator-(const double& ts) const;
 
    double operator-(const TimeStamp& ts) const;
 
    void print(std::ostream& ost = std::cout) const;
 
    friend std::ostream& operator<<(std::ostream& os, const TimeStamp& _ts);
 
    std::string string() const;
};
 
inline wolf::TimeStamp TimeStamp::Invalid()
{
    return TimeStamp(-1.0);
}
 
inline bool TimeStamp::ok() const
{
    return is_valid_;
}
 
inline void TimeStamp::setOk()
{
    is_valid_ = true;
}
 
inline void TimeStamp::setNOk()
{
    is_valid_ = false;
}
 
inline void TimeStamp::set(const double& ts)
{
    time_stamp_nano_ = (ts >= 0 ? (unsigned long int)(ts * NANOSECS) : 0);
    is_valid_        = (ts >= 0);
}
 
inline void TimeStamp::set(const unsigned long int& sec, const unsigned long int& nanosec)
{
    time_stamp_nano_ = sec * NANOSECS + nanosec;
    is_valid_        = true;
}
 
inline void TimeStamp::set(const timeval& ts)
{
    time_stamp_nano_ = (unsigned long int)(ts.tv_sec * NANOSECS) + (unsigned long int)(ts.tv_usec * 1000);
    is_valid_        = (ts.tv_sec >= 0 and ts.tv_usec >= 0);
}
 
inline double TimeStamp::get() const
{
    return ((double)(time_stamp_nano_)) * 1e-9;
}
 
inline unsigned long int TimeStamp::getSeconds() const
{
    return time_stamp_nano_ / NANOSECS;
}
 
inline unsigned long int TimeStamp::getNanoSeconds() const
{
    return time_stamp_nano_ % NANOSECS;
}
 
inline void TimeStamp::operator=(const TimeStamp& ts)
{
    time_stamp_nano_ = ts.time_stamp_nano_;
    is_valid_        = ts.is_valid_;
}
 
inline void TimeStamp::operator=(const double& ts)
{
    time_stamp_nano_ = (unsigned long int)(ts * NANOSECS);
    is_valid_        = (ts >= 0);
}
 
inline bool TimeStamp::operator==(const TimeStamp& ts) const
{
    return (time_stamp_nano_ == ts.time_stamp_nano_);
}
 
inline bool TimeStamp::operator!=(const TimeStamp& ts) const
{
    return (time_stamp_nano_ != ts.time_stamp_nano_);
}
 
inline bool TimeStamp::operator<(const TimeStamp& ts) const
{
    return (time_stamp_nano_ < ts.time_stamp_nano_);
}
 
inline bool TimeStamp::operator>(const TimeStamp& ts) const
{
    return (time_stamp_nano_ > ts.time_stamp_nano_);
}
 
inline bool TimeStamp::operator<=(const TimeStamp& ts) const
{
    return (time_stamp_nano_ <= ts.time_stamp_nano_);
}
 
inline bool TimeStamp::operator>=(const TimeStamp& ts) const
{
    return (time_stamp_nano_ >= ts.time_stamp_nano_);
}
 
inline void TimeStamp::operator+=(const double& dt)
{
    time_stamp_nano_ += (unsigned long int)(dt * NANOSECS);
}
 
inline double TimeStamp::operator-(const TimeStamp& ts) const
{
    return double((long int)(time_stamp_nano_ - ts.time_stamp_nano_)) *
           1e-9;  // long int cast fix overflow in case of negative substraction result
}
 
inline std::string TimeStamp::string() const
{
    std::stringstream ss;
    ss << *this;
    return ss.str();
}
 
}  // namespace wolf